# -*- coding: utf-8 -*-
"""
金桔王 AI Agent 工具函数
"""
import os
import traceback
from langchain_core.tools import tool
from sqlalchemy import text
from common.log import logger
from common.enum_types import UserRole
from models import SessionLocal, Users

@tool
def read_help_document(document_name: str) -> str:
    """
    读取指定的帮助文档内容
    
    Args:
        document_name: 文档名称，例如 "滑皮金桔.md" 或 "脆蜜金桔.md"
    
    Returns:
        文档的完整内容，如果文档不存在则返回错误信息
    """
    try:
        # 获取项目根目录
        project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        help_docs_dir = os.path.join(project_root, "docs", "help_docs")
        
        # 构建文档路径
        doc_path = os.path.join(help_docs_dir, document_name)
        
        # 检查文档是否存在
        if not os.path.exists(doc_path):
            available_docs = []
            if os.path.exists(help_docs_dir):
                available_docs = [f for f in os.listdir(help_docs_dir) if f.endswith('.md')]
            
            error_msg = f"❌ 文档 '{document_name}' 不存在。"
            if available_docs:
                error_msg += f"\n📚 可用的文档有：{', '.join(available_docs)}"
            
            logger.warning(f"[🔍帮助文档] 尝试读取不存在的文档: {document_name}")
            return error_msg
        
        # 读取文档内容
        with open(doc_path, 'r', encoding='utf-8') as f:
            content = f.read()
        
        logger.info(f"[📖帮助文档] 成功读取文档: {document_name} ({len(content)} 字符)")
        return content
        
    except Exception as e:
        error_msg = f"❌ 读取文档时发生错误: {e} - {traceback.format_exc()}"
        logger.error(f"[❌帮助文档] 读取文档失败: {document_name} - {e} - {traceback.format_exc()}")
        return error_msg


@tool
def list_help_documents() -> str:
    """
    列出所有可用的帮助文档
    
    Returns:
        可用帮助文档的列表，格式化为字符串
    """
    try:
        # 获取项目根目录
        project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        help_docs_dir = os.path.join(project_root, "docs", "help_docs")
        
        # 检查目录是否存在
        if not os.path.exists(help_docs_dir):
            logger.warning(f"[📚帮助文档] 帮助文档目录不存在: {help_docs_dir}")
            return "❌ 帮助文档目录不存在"
        
        # 获取所有 .md 文件
        doc_files = [f for f in os.listdir(help_docs_dir) if f.endswith('.md')]
        
        if not doc_files:
            logger.info("[📚帮助文档] 没有找到任何帮助文档")
            return "📚 暂无可用的帮助文档"
        
        # 格式化文档列表
        doc_list = "\n".join([f"📄 {doc}" for doc in sorted(doc_files)])
        result = f"📚 可用的帮助文档：\n{doc_list}"
        
        logger.info(f"[📚帮助文档] 列出 {len(doc_files)} 个文档")
        return result
        
    except Exception as e:
        error_msg = f"❌ 列出文档时发生错误: {e} - {traceback.format_exc()}"
        logger.error(f"[❌帮助文档] 列出文档失败: {e} - {traceback.format_exc()}")
        return error_msg


def register_or_update_user(name: str = None, phone: str = None, address: str = None, chat_handler=None, target_nickname: str = None) -> str:
    """
    注册新用户或修改现有用户信息
    
    Args:
        name: 用户真实姓名（可选，不提供则不修改）
        phone: 手机号码（可选，不提供则不修改）
        address: 用户地址（可选，不提供则不修改），如果是"默认地址"则使用"融安县长安镇鑫茂园"
        chat_handler: 聊天处理器实例，用于获取真实对话者信息
        target_nickname: 要修改的目标用户昵称（可选，如果不提供则操作自己）
        
    Returns:
        str: 操作结果信息
    """
    db = None  # 初始化db变量
    try:
        from models import SessionLocal, Users
        import datetime
        
        # 🔐 身份验证：获取真实对话者信息
        real_user_id = chat_handler.get_user_id()
        
        # 处理默认地址
        if address == "默认地址":
            address = "融安县长安镇鑫茂园"
        
        # 确定操作目标
        if target_nickname is None:
            # 如果没有指定目标，则操作自己
            target_nickname = real_user_id
            is_self_operation = True
            logger.info(f"[👤用户管理] 👤 操作自己的信息: {target_nickname}")
        else:
            # 如果指定了目标用户，需要检查权限
            is_self_operation = (target_nickname == real_user_id)
            if not is_self_operation:
                if chat_handler.role != UserRole.ADMIN.value:
                    logger.warning(f"[👤用户管理] 🔒 权限不足，无法修改其他用户信息")
                    return "🔒 权限不足，只有管理员(ADMIN)才能修改其他用户信息"
        
        # 📝 参数验证：对于新用户注册，必须提供完整信息
        db = SessionLocal()
        existing_user = db.query(Users).filter(Users.nickname == target_nickname).first()
        
        if not existing_user or existing_user.is_deleted:
            # 新用户注册或重新激活，需要完整信息
            if not all([name, phone, address]):
                missing_fields = []
                if not name: missing_fields.append("姓名")
                if not phone: missing_fields.append("手机号")
                if not address: missing_fields.append("地址")
                logger.warning(f"[👤用户管理] ❌ 注册新用户缺少必要信息: {', '.join(missing_fields)}")
                return f"❌ 注册新用户需要提供完整信息，缺少：{', '.join(missing_fields)}"
        
        # 查找用户
        existing_user = db.query(Users).filter(Users.nickname == target_nickname).first()
        
        if existing_user:
            if existing_user.is_deleted:
                # 用户之前被软删除，重新激活账户
                logger.info(f"[👤用户管理] 🔄 重新激活已删除用户: {target_nickname}")
                existing_user.name = name
                existing_user.phone = phone
                existing_user.address = address
                existing_user.role = "USER"  # 重新激活时默认为USER角色
                existing_user.is_deleted = False
                existing_user.register_time = datetime.datetime.utcnow()
                db.commit()
                logger.info(f"[👤用户管理] ✅ 用户账户重新激活成功: {target_nickname}")
                return f"✅ 用户 {target_nickname} 账户已重新激活并更新信息\n👤 姓名: {name}\n📱 手机: {phone}\n📍 地址: {address}\n🎭 角色: USER"
            else:
                # 用户存在且未删除，更新信息
                logger.info(f"[👤用户管理] 🔄 更新现有用户信息: {target_nickname}")
                
                # 记录变更信息，只更新有值的字段
                changes = []
                if name is not None and existing_user.name != name:
                    changes.append(f"姓名: {existing_user.name} → {name}")
                    existing_user.name = name
                if phone is not None and existing_user.phone != phone:
                    changes.append(f"手机: {existing_user.phone} → {phone}")
                    existing_user.phone = phone
                if address is not None and existing_user.address != address:
                    changes.append(f"地址: {existing_user.address} → {address}")
                    existing_user.address = address
                
                if changes:
                    db.commit()
                    change_log = "\n".join([f"  • {change}" for change in changes])
                    logger.info(f"[👤用户管理] ✅ 用户信息更新成功: {target_nickname}")
                    return f"✅ 用户信息更新成功！\n📝 变更内容：\n{change_log}\n\n📋 当前信息：\n👤 姓名: {existing_user.name}\n📱 手机: {existing_user.phone}\n📍 地址: {existing_user.address}\n🎭 角色: {existing_user.role}"
                else:
                    logger.info(f"[👤用户管理] ℹ️ 用户信息无变化: {target_nickname}")
                    return f"ℹ️ 用户信息无变化\n📋 当前信息：\n👤 姓名: {existing_user.name}\n📱 手机: {existing_user.phone}\n📍 地址: {existing_user.address}\n🎭 角色: {existing_user.role}"
        else:
            # 用户不存在，创建新用户
            if not is_self_operation:
                # 如果是管理员为其他人注册，使用指定的nickname
                nickname = target_nickname
                logger.info(f"[👤用户管理] 👑 管理员为其他用户注册: {nickname}")
            else:
                # 如果是自己注册，使用真实的微信用户ID作为昵称
                nickname = real_user_id
                logger.info(f"[👤用户管理] 👤 用户自己注册: {nickname}")
            
            new_user = Users(
                name=name,
                phone=phone,
                address=address,
                nickname=nickname,
                role="USER",  # 所有新注册用户默认为USER角色
                register_time=datetime.datetime.utcnow(),
                is_deleted=False
            )
            
            db.add(new_user)
            db.commit()
            
            logger.info(f"[👤用户管理] ✅ 用户注册成功: {name} ({nickname})")
            return f"✅ 用户注册成功！\n👤 姓名: {name}\n📱 手机: {phone}\n📍 地址: {address}\n🏷️ 昵称: {nickname}\n🎭 角色: USER"
        
    except Exception as e:
        logger.error(f"[👤用户管理] ❌ 操作失败: {e} - {traceback.format_exc()}")
        return f"❌ 操作失败: {str(e)}"
    finally:
        if db is not None:
            db.close()


def delete_user(chat_handler, target_nickname: str = None) -> str:
    """
    注销用户（软删除）
    
    Args:
        chat_handler: 聊天处理器实例，用于获取真实对话者信息
        target_nickname: 要注销的目标用户昵称（可选，如果不提供则注销自己）
        
    Returns:
        str: 注销结果信息
    """
    db = None  # 初始化db变量
    try:
        # 🔐 身份验证：获取真实对话者信息
        real_user_id = chat_handler.get_user_id()
        logger.info(f"[🗑️注销用户] 🔐 身份验证通过，真实对话者: {real_user_id}")
        
        # 🚫 安全检查：防止在群聊中注销
        if chat_handler.is_group_chat():
            logger.warning(f"[🗑️注销用户] 🚫 群聊环境禁止注销用户")
            return "🚫 为了保护隐私，用户注销功能仅限私聊使用，请私信我进行操作"
        
        # 确定要注销的用户
        if target_nickname is None or target_nickname == chat_handler.nickname:
            # 如果没有指定目标，则注销自己
            target_nickname = real_user_id
            logger.info(f"[🗑️注销用户] 👤 注销自己的账户: {target_nickname}")
        else:
            # 如果指定了目标用户，需要检查权限
            logger.info(f"[🗑️注销用户] 🎯 尝试注销其他用户: {target_nickname}")
            
            user_exists = True if chat_handler.role != UserRole.ANONYMOUS.value else False
            if not user_exists:
                logger.warning(f"[🗑️注销用户] {target_nickname} 身份是ANONYMOUS，都没注册，注销个屁。")
                return f"🔒 {target_nickname} 身份是ANONYMOUS，都没注册，注销个屁。"
            if chat_handler.nickname != target_nickname and chat_handler.role != UserRole.ADMIN.value:
                logger.warning(f"[🗑️注销用户] 🔒 权限不足，无法注销其他用户")
                return "🔒 权限不足，只有管理员(ADMIN)才能注销其他用户，普通用户只能注销自己"
                
        
        db = SessionLocal()
        
        # 查找用户
        user = db.query(Users).filter(Users.nickname == target_nickname, Users.is_deleted == False).first()
        if not user:
            logger.warning(f"[🗑️注销用户] ❌ 用户不存在或已注销: {target_nickname}")
            return f"❌ 用户 {target_nickname} 不存在或已注销"
        
        # 🛡️ 保护系统用户
        if user.id in [0, 1]:  # admin和anonymous用户
            logger.warning(f"[🗑️注销用户] 🛡️ 禁止注销系统用户: {target_nickname} (ID: {user.id})")
            return f"🛡️ 系统用户 {target_nickname} 受保护，无法注销"
        
        # 软删除用户
        user.is_deleted = True
        db.commit()
        
        logger.info(f"[🗑️注销用户] ✅ 用户注销成功: {target_nickname}")
        return f"✅ 用户 {target_nickname} 注销成功"
        
    except Exception as e:
        logger.error(f"[🗑️注销用户] ❌ 注销失败: {e} - {traceback.format_exc()}")
        return f"❌ 注销失败: {str(e)}"
    finally:
        if db is not None:
            db.close()


def upgrade_user_role(chat_handler, target_nickname: str, new_role: str) -> str:
    """
    升级用户角色
    
    Args:
        chat_handler: 聊天处理器实例，用于获取真实对话者信息
        target_nickname: 要升级的用户昵称
        new_role: 新角色 (USER, ADMIN, MANAGER)
        
    Returns:
        str: 升级结果信息
    """
    db = None  # 初始化db变量
    try:
        
        # 🔒 权限检查：获取当前操作者的用户信息
        if chat_handler.role != UserRole.ADMIN.value:
            logger.warning(f"[⬆️升级用户] 🔒 权限不足，操作者角色: {chat_handler.role if chat_handler.role else 'ANONYMOUS'}")
            return "🔒 权限不足，只有管理员(ADMIN)才能修改用户角色"
        
        logger.info(f"[⬆️升级用户] 开始升级用户角色: {target_nickname} -> {new_role}")
        
        # 验证新角色
        valid_roles = UserRole.get_upgrade_roles()
        if new_role not in valid_roles:
            logger.warning(f"[⬆️升级用户] ❌ 无效角色: {new_role}")
            return f"❌ 无效角色，允许的角色: {', '.join(valid_roles)}"
        
        db = SessionLocal()
        
        # 查找用户
        user = db.query(Users).filter(Users.nickname == target_nickname, Users.is_deleted == False).first()
        if not user:
            logger.warning(f"[⬆️升级用户] ❌ 用户不存在: {target_nickname}")
            return f"❌ 用户 {target_nickname} 不存在"
        
        # 🛡️ 保护系统用户
        if user.id in [0, 1]:  # admin和anonymous用户
            logger.warning(f"[⬆️升级用户] 🛡️ 禁止修改系统用户角色: {target_nickname} (ID: {user.id})")
            return f"🛡️ 系统用户 {target_nickname} 受保护，无法修改角色"
        
        old_role = user.role
        user.role = new_role
        db.commit()
        
        logger.info(f"[⬆️升级用户] ✅ 用户角色升级成功: {target_nickname} ({old_role} -> {new_role})")
        return f"✅ 用户 {target_nickname} 角色升级成功: {old_role} -> {new_role}"
        
    except Exception as e:
        logger.error(f"[⬆️升级用户] ❌ 升级失败: {e} - {traceback.format_exc()}")
        return f"❌ 升级失败: {str(e)}"
    finally:
        if db is not None:
            db.close()


def query_user(chat_handler, target_name: str = None) -> str:
    """
    查询用户信息 - 支持模糊搜索姓名和昵称
    
    Args:
        chat_handler: 聊天处理器实例，用于获取真实对话者信息
        target_name: 要查询的目标用户姓名或昵称（可选，如果不提供则查询自己）
        
    Returns:
        str: 用户信息
    """
    db = None  # 初始化db变量
    try:
        # 🔐 身份验证：获取真实对话者信息
        real_user_id = chat_handler.get_user_id()
        logger.info(f"[🔍查询用户] 🔐 身份验证通过，真实对话者: {real_user_id}")
        
        db = SessionLocal()
        
        # 确定要查询的用户
        if target_name is None:
            # 如果没有指定目标，则查询自己（精确匹配nickname）
            user = db.query(Users).filter(Users.nickname == real_user_id).first()
            logger.info(f"[🔍查询用户] 👤 查询自己的信息: {real_user_id}")
        else:
            # 如果指定了目标用户，需要检查权限
            logger.info(f"[🔍查询用户] 🎯 尝试查询其他用户: {target_name}")
            
            # 只有管理员或经理可以查询其他用户信息
            if chat_handler.role not in [UserRole.ADMIN.value, UserRole.MANAGER.value]:
                logger.warning(f"[🔍查询用户] 🔒 权限不足，无法查询其他用户信息")
                return "🔒 权限不足，只有管理员(ADMIN)或经理(MANAGER)才能查询其他用户信息"
            
            # 🔍 模糊搜索：先尝试精确匹配，再尝试模糊匹配
            # 1. 精确匹配 nickname
            user = db.query(Users).filter(Users.nickname == target_name).first()
            
            if not user:
                # 2. 精确匹配 name
                user = db.query(Users).filter(Users.name == target_name).first()
            
            if not user:
                # 3. 模糊匹配 nickname（包含查询字符串）
                user = db.query(Users).filter(Users.nickname.like(f'%{target_name}%')).first()
            
            if not user:
                # 4. 模糊匹配 name（包含查询字符串）
                user = db.query(Users).filter(Users.name.like(f'%{target_name}%')).first()
            
            # 如果找到多个匹配结果，提示用户
            if user:
                # 检查是否有多个匹配结果
                all_matches = db.query(Users).filter(
                    (Users.nickname.like(f'%{target_name}%')) | 
                    (Users.name.like(f'%{target_name}%'))
                ).filter(Users.is_deleted == False).all()
                
                if len(all_matches) > 1:
                    match_list = []
                    for match in all_matches[:5]:  # 最多显示5个匹配结果
                        match_list.append(f"• {match.name}({match.nickname})")
                    
                    logger.info(f"[🔍查询用户] 🔍 找到多个匹配用户: {len(all_matches)}个")
                    return f"🔍 找到多个匹配的用户，请提供更具体的信息：\n" + "\n".join(match_list)
        
        # 查找用户
        if not user:
            logger.warning(f"[🔍查询用户] ❌ 用户不存在: {target_name}")
            return f"❌ 未找到用户 '{target_name}'，请检查姓名或昵称是否正确"
        
        # 检查用户是否被删除
        if user.is_deleted:
            logger.warning(f"[🔍查询用户] ❌ 用户已注销: {user.nickname}")
            return f"❌ 用户 {user.name}({user.nickname}) 已注销"
        
        # 格式化用户信息
        user_info = f"""👤 用户信息：
🆔 ID: {user.id}
👤 姓名: {user.name}
🏷️ 昵称: {user.nickname}
📱 手机: {user.phone}
📍 地址: {user.address}
🎭 角色: {user.role}
📅 注册时间: {user.register_time.strftime('%Y-%m-%d %H:%M:%S') if user.register_time else '未知'}
📝 备注: {user.note if user.note and user.note != 'NULL' else '无'}"""
        
        logger.info(f"[🔍查询用户] ✅ 用户信息查询成功: {user.name}({user.nickname})")
        return user_info
        
    except Exception as e:
        logger.error(f"[🔍查询用户] ❌ 查询失败: {e} - {traceback.format_exc()}")
        return f"❌ 查询失败: {str(e)}"
    finally:
        if db is not None:
            db.close()
